import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class test3 {
    public static void main(String[] args) {
        //数组转字符串
       // int[] ch = {1,2,3,5,4,7};
        /*double[] ch1 = new double[10];
        short[] ch2 = new short[]{1,1,1,1,1,};
        String ss = Arrays.toString(ch);
        System.out.println("整型转为字符串类型：" + ss);
        String ss1 = Arrays.toString(ch1);
        System.out.println("double类型转为字符串类型：" + ss1);
        String ss2 = Arrays.toString(ch2);
        System.out.println("short转为字符串类型:" + ss2);*/
        /*System.out.print("[");
        for(int i = 0; 0 < ch.length; i++) {
            System.out.print(ch[i]);
            if (ch[i] <= ch.length - 1) {
                System.out.print(",");
            }
        }
        System.out.print("]");*/

        //数组拷贝
        /*int[] a = new int[]{1,2,3};
        int[] b = new int[10];
        System.out.println(b);
        b = Arrays.copyOf(a,a.length);
        System.out.println(Arrays.toString(b));*/

       /*double[] a = new double[]{4,5,2,8,55,44,32};
       double b = PingJun(a);
       System.out.println(b);*/

        /*int[] array = {1,2,4,5,7};
        int a = 5;
        System.out.println(ChaZhao(array,a));*/

        /*int[] array = {1,5,6,7,8,25,213};
        int d = 8;
        System.out.println(ChaZhao(array,d));*/

        /*int[] a = new int[]{1,2,3,4};
         transForm(a);
        System.out.println(Arrays.toString(a));*/

        /*int[] arr = new int[]{1,2,3,4,12,42};
        System.out.println(avg(arr));*/

        /*int[] originalArray = {1, 2, 3, 4, 5, 6}; // 示例数组
        int[] adjustedArray = JiOu(originalArray); // 调用方法进行调整
        System.out.println("Adjusted array: " + Arrays.toString(adjustedArray)); // 输出调整后的数组*/

        /*int[] arr = {1,5,4,6,8,7};
        MaoPao(arr);
        System.out.println(Arrays.toString(arr));*/

        /*int[] nums = {2, 7, 11, 15}; // 示例数组
        int target = 9; // 目标值
        int[] result = twoSum(nums, target); // 调用方法找出两个整数
        if (result != null) {
            System.out.println("Indices: [" + result[0] + ", " + result[1] + "]"); // 输出索引
        } else {
            System.out.println("No two sum solution found."); // 未找到解
        }*/
        /*int[] nums = {4, 1, 2, 1, 2}; // 示例数组
        int result = singleNumberXOR(nums); // 调用方法找出只出现一次的元素
        System.out.println("The single number is: " + result); // 输出结果*/

        /*int[] nums = {3, 2, 3}; // 示例数组
        int result = majorityElementHashMap(nums);
        System.out.println("The majority element is: " + result);
*/
        int[] arr = {1, 2, 3, 4, 5}; // 示例数组
        boolean result = hasThreeConsecutiveOdds(arr);
        System.out.println("Has three consecutive odds: " + result); // 输出结果
    }


    //求数组中元素的平均值
    public static double PingJun(double[] a) {
        double sum = 0;
        if(a == null || a.length == 0) {
            System.out.println("这是一个空数组");
            return 0;
        }else {
            for(int i = 0; i < a.length; i++) {
                sum += a[i];
            }
            return sum / a.length ;
        }
    }
    //查找数组中指定元素(顺序查找)
//    public static int ChaZhao(int[] array , int a) {
//        for(int i = 0; i < array.length; i++) {
//            if (array[i] == a) {
//                return array[i];
//
//            }
//        }    return -1;
//    }
    //查找数组中指定元素(二分查找)
    public static int ChaZhao(int[] array, int a) {
        int  L = 0;
        int R = array.length - 1;
        while(L <= R ) {
            int M = (L + R) / 2;
            if(a < array[M]) {
                R = M - 1;
            }else if(a > array[M]) {
                L = M + 1;
            }else {
                return array[M];
            }
        }
        return -1;
    }
    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static void transForm(int[] array) {
        for(int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
    }
    //实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
    public static double avg(int[] array) {
        double sum = 0;
        if(array == null || array.length == 0) {
            return -1;
        }else {
            for (int i = 0; i < array.length; i++) {
                sum += array[i];
            }
            return sum / array.length;
        }
    }
    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。如数组：[1,2,3,4,5,6],调整后可能是：[1, 5, 3, 4, 2, 6]
    public static int[] JiOu(int[] array) {
        if(array == null || array.length == 0) {
            return array;
        }
        int[] L = new int[(array.length / 2) + 1];
        int[] R = new int[(array.length / 2)];
        int L1 = 0;
        int R1 = 0;
        for (int num:array) {
            if(num % 2 != 0) {
                L[L1++] = num;
            }else {
                R[R1++] = num;
            }
        }
        int[] S = new int[array.length];
        System.arraycopy(L,0,S,0,L1);
        System.arraycopy(R,0,S,L1,R1);
        return S;
    }
    //给定一个整型数组, 实现冒泡排序(升序排序)
    public static void MaoPao(int[] array) {
        for(int i = 0; i < array.length; i++) {
            for (int j = 1; j < array.length - i; j++) {
                if(array[j - 1] > array[j]) {
                    int tmp = array[j - 1];
                    array[j-1] = array[j];
                    array[j] = tmp;
                }

            }
        }
    }
    //给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> numMap = new HashMap<>(); // 创建哈希表存储数值和索引

        for (int i = 0; i < nums.length; i++) { // 遍历数组
            int complement = target - nums[i]; // 计算当前元素与目标值的差
            if (numMap.containsKey(complement)) { // 如果哈希表中存在差值
                return new int[] {numMap.get(complement), i}; // 返回找到的两个索引
            }
            numMap.put(nums[i], i); // 将当前元素和索引存入哈希表
        }

        return null; // 如果没有找到符合条件的两个数，返回null
    }
    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    public static int singleNumberXOR(int[] nums) {
        int result = 0; // 初始化结果为0

        // 第一次遍历：对所有元素进行异或操作
        for (int num : nums) {
            result ^= num; // 将每个元素与结果进行异或操作
        }

        return result; // 返回最终的异或结果，即为只出现一次的元素
    }
    //给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    public static int majorityElementHashMap(int[] nums) {
        Map<Integer, Integer> countMap = new HashMap<>(); // 创建哈希表记录元素出现次数

        // 记录每个元素出现的次数
        for (int num : nums) {
            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
        }

        // 找出出现次数超过数组长度一半的元素
        for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
            if (entry.getValue() > nums.length / 2) {
                return entry.getKey(); // 返回多数元素
            }
        }

        return -1; // 如果没有找到多数元素，返回-1
    }
    //给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
    public static boolean hasThreeConsecutiveOdds(int[] arr) {
        // 遍历数组，步长为1
        for (int i = 0; i <= arr.length - 3; i++) {
            // 检查当前元素、下一个元素和下下个元素是否都是奇数
            if (isOdd(arr[i]) && isOdd(arr[i + 1]) && isOdd(arr[i + 2])) {
                return true; // 如果都是奇数，返回 true
            }
        }
        return false; // 如果没有找到连续三个奇数，返回 false
    }

    /**
     * 判断一个整数是否为奇数
     * @param num 输入的整数
     * @return 如果是奇数，返回 true；否则，返回 false
     */
    public static boolean isOdd(int num) {
        return num % 2 != 0; // 如果一个数除以2的余数不为0，则是奇数
    }
}
